package com.smart.translator.util;

import android.util.Log;

/**
 * VAD集成示例
 * 展示如何在AudioProcessor中集成VAD检测功能
 */
public class VadIntegrationExample {
    private static final String TAG = "VadIntegrationExample";
    
    private VadDetector vadDetector;
    private boolean isVadEnabled = false;
    
    // VAD状态
    private boolean isSpeechDetected = false;
    private long speechStartTime = 0;
    private long speechEndTime = 0;
    
    /**
     * 初始化VAD检测
     */
    public void initializeVad() {
        try {
            vadDetector = new VadDetector();
            
            // 设置VAD回调
            vadDetector.setCallback(new VadDetector.VadCallback() {
                @Override
                public void onSpeechStart() {
                    Log.d(TAG, "🎤 VAD检测到语音开始");
                    isSpeechDetected = true;
                    speechStartTime = System.currentTimeMillis();
                    
                    // 在这里可以触发ASR开始录音
                    // 例如：开始收集音频数据用于ASR识别
                }
                
                @Override
                public void onSpeechEnd() {
                    Log.d(TAG, "🔇 VAD检测到语音结束");
                    isSpeechDetected = false;
                    speechEndTime = System.currentTimeMillis();
                    
                    // 计算语音持续时间
                    long duration = speechEndTime - speechStartTime;
                    Log.d(TAG, "语音持续时间: " + duration + "ms");
                    
                    // 在这里可以触发ASR结束录音并发送数据
                    // 例如：停止收集音频数据，发送到ASR服务
                }
                
                @Override
                public void onVoiceActivity(boolean isSpeech) {
                    // 实时语音活动状态
                    if (isSpeech) {
                        Log.d(TAG, "🎵 检测到语音活动");
                    } else {
                        Log.d(TAG, "🔇 检测到静音");
                    }
                }
            });
            
            // 初始化VAD检测器（16kHz采样率，30ms帧大小）
            vadDetector.initialize(16000, 480);
            isVadEnabled = true;
            
            Log.d(TAG, "✅ VAD检测器初始化成功");
            
        } catch (Exception e) {
            Log.e(TAG, "❌ VAD检测器初始化失败", e);
            isVadEnabled = false;
        }
    }
    
    /**
     * 处理音频数据（在AudioProcessor中调用）
     * @param audioData 音频数据
     * @return 是否检测到语音
     */
    public boolean processAudioData(byte[] audioData) {
        if (!isVadEnabled || vadDetector == null) {
            return false;
        }
        
        try {
            // 使用VAD检测音频数据
            boolean hasSpeech = vadDetector.processAudio(audioData);
            
            // 根据VAD结果决定是否处理音频
            if (hasSpeech) {
                // 检测到语音，可以继续处理音频数据
                Log.d(TAG, "VAD检测到语音，继续处理音频数据");
                return true;
            } else {
                // 检测到静音，可以选择跳过处理
                Log.d(TAG, "VAD检测到静音，跳过音频处理");
                return false;
            }
            
        } catch (Exception e) {
            Log.e(TAG, "VAD处理音频数据失败", e);
            return false;
        }
    }
    
    /**
     * 处理PCM音频数据
     * @param pcmData PCM音频数据
     * @return 是否检测到语音
     */
    public boolean processPcmData(short[] pcmData) {
        if (!isVadEnabled || vadDetector == null) {
            return false;
        }
        
        try {
            return vadDetector.processAudio(pcmData);
        } catch (Exception e) {
            Log.e(TAG, "VAD处理PCM数据失败", e);
            return false;
        }
    }
    
    /**
     * 获取VAD状态
     */
    public boolean isSpeechDetected() {
        return isSpeechDetected;
    }
    
    /**
     * 获取语音开始时间
     */
    public long getSpeechStartTime() {
        return speechStartTime;
    }
    
    /**
     * 获取语音结束时间
     */
    public long getSpeechEndTime() {
        return speechEndTime;
    }
    
    /**
     * 获取语音持续时间
     */
    public long getSpeechDuration() {
        if (speechStartTime > 0 && speechEndTime > 0) {
            return speechEndTime - speechStartTime;
        }
        return 0;
    }
    
    /**
     * 重置VAD状态
     */
    public void resetVad() {
        if (vadDetector != null) {
            vadDetector.reset();
        }
        isSpeechDetected = false;
        speechStartTime = 0;
        speechEndTime = 0;
        Log.d(TAG, "VAD状态已重置");
    }
    
    /**
     * 释放VAD资源
     */
    public void releaseVad() {
        if (vadDetector != null) {
            vadDetector.release();
            vadDetector = null;
        }
        isVadEnabled = false;
        Log.d(TAG, "VAD资源已释放");
    }
    
    /**
     * 检查VAD是否可用
     */
    public boolean isVadEnabled() {
        return isVadEnabled && vadDetector != null && vadDetector.isInitialized();
    }
    
    /**
     * 启用/禁用VAD
     */
    public void setVadEnabled(boolean enabled) {
        this.isVadEnabled = enabled;
        Log.d(TAG, "VAD检测已" + (enabled ? "启用" : "禁用"));
    }
} 